Built with Alectryon, running Coq+SerAPI v8.16.0+0.16.0. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use ⌘ instead of Ctrl.
well_formed a
→ well_formed b
→ well_formed c
→ well_formed d
→ well_formed e
→ well_formed f
→ Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
→ Γ
⊢ a and (b and (c and (d and e))) ---> f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern
well_formed a
→ well_formed b
→ well_formed c
→ well_formed d
→ well_formed e
→ well_formed f
→ Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
→ Γ
⊢ a and (b and (c and (d and e))) ---> f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ ⊢ a and (b and (c and (d and e))) ---> f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
well_formed (a and (b and (c and (d and e))) ---> f)
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
a and (b and (c and (d and e))) ---> f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
well_formed (a and (b and (c and (d and e))) ---> f)
wf_auto2.
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
a and (b and (c and (d and e))) ---> f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
f
Σ: Signature Γ: Theory a, b, c, d, e, f: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
a and (b and (c and (d and e)))
mlExact "H1".Defined.
i: bool l: list bool
foldr andb i l = true → i = true
i: bool l: list bool
foldr andb i l = true → i = true
l: list bool
∀i : bool, foldr andb i l = true → i = true
i: bool H: i = true
i = true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H: a && foldr andb i l = true
i = true
i: bool H: i = true
i = true
assumption.
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H: a && foldr andb i l = true
i = true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H: a && foldr andb i l = true
i = true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H: a = true ∧ foldr andb i l = true
i = true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H1: a = true H2: foldr andb i l = true
i = true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = true → i = true i: bool H1: a = true H2: foldr andb i l = true
foldr andb i l = true
exact H2.}Qed.
i: bool l: list bool
foldr andb i l = i && foldr andb true l
i: bool l: list bool
foldr andb i l = i && foldr andb true l
l: list bool
∀i : bool, foldr andb i l = i && foldr andb true l
i: bool
i = i && true
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
i: bool
i = i && true
i: bool
i = i
reflexivity.
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
[&& a, i & foldr andb true l] =
[&& i, a & foldr andb true l]
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
a && i && foldr andb true l =
i && a && foldr andb true l
a: bool l: list bool IHl: ∀i : bool, foldr andb i l = i && foldr andb true l i: bool
i && a && foldr andb true l =
i && a && foldr andb true l
reflexivity.}Qed.
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern
∀r : ImpReshapeS g' (x :: xs),
Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
→ Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern
∀r : ImpReshapeS g' (x :: xs),
Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
→ Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Hwf1: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
)) Hwf2: wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
)))
mlTheory
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
)
⊢i foldr patt_imp
(mlConclusion
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
))
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
)))
using mlInfo
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i
)
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Hwf1: well_formed g' Hwf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp g'
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Hwf1: well_formed g' Hwf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed r
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Hwf1: well_formed g' Hwf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wfr: well_formed r
Γ
⊢i foldr patt_imp g'
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
Hwf1: well_formed g' Hwf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: mlTheory
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
endusing i
)
⊢i foldr patt_imp
(mlConclusion
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys =>
foldr patt_and yk (x :: rev ys)
endusing i
))
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys =>
foldr patt_and yk (x :: rev ys)
endusing i
)))
using mlInfo
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys =>
foldr patt_and yk (x :: rev ys)
endusing i
) wf1: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
)) wf2: wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i
)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ
⊢i foldr patt_imp
match rev xs with
| [] => x
| yk :: ys =>
x and foldr patt_and yk (rev ys)
end (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) Heqxs: rev xs = [] H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern Heqxs: rev xs = p :: l H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) Heqxs: rev xs = [] H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) Heqxs: rev (rev xs) = rev [] H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) Heqxs: xs = rev []
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) Heqxs: xs = []
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern r: ImpReshapeS g' [x] wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x []) H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp (foldr patt_and x [])
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern r: ImpReshapeS g' [x] wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed x H: Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp x
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
exact H.
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern Heqxs: rev xs = p :: l H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern Heqxs: rev xs = p :: l H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern Heqxs: rev (rev xs) = rev (p :: l) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) Heqxs: xs = rev (p :: l)
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x: Pattern xs: list Pattern r: ImpReshapeS g' (x :: xs) p: Pattern l: list Pattern H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i wf1: well_formed (foldr patt_and x xs) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) Heqxs: xs = rev l ++ [p]
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp (foldr patt_and x (rev l ++ [p]))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed ?g
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ ⊢i ?g ---> foldr patt_and x (rev l ++ [p]) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp ?g
(map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
foldr patt_and x (rev l ++ [p]) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
foldr patt_and x (rev l ++ [p]) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
foldr patt_and (foldr patt_and x [p]) (rev l)
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l) using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
(x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
(x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
wf_auto2.
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"H1" ∶ x and foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using i
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
wf_auto2.
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
p ---> p and x
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hp" ∶ p,
--------------------------------------
p and x
using BasicReasoning
mlSplitAnd;[mlExact "Hp" | mlExact "Hx"].
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i Hwf: well_formed
(foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and p (rev l)
using BasicReasoning
mlExact "Hf".
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature Γ: Theory l₁, l₂: list named_hypothesis name: string g': Pattern i: ProofInfo x, p: Pattern l: list Pattern r: ImpReshapeS g' (x :: rev l ++ [p]) wf2: foldr andb true
(map well_formed
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))) wf1: well_formed (foldr patt_and x (rev l ++ [p])) H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
(map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern
well_formed a
→ well_formed b
→ well_formed c
→ well_formed d
→ well_formed e
→ well_formed f
→ well_formed g
→ Γ
⊢ a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern
well_formed a
→ well_formed b
→ well_formed c
→ well_formed d
→ well_formed e
→ well_formed f
→ well_formed g
→ Γ
⊢ a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ
⊢ a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
well_formed
(a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g)
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
well_formed
(a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g)
wf_auto2.
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
a and (b and (c and (d and e))) --->
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
--------------------------------------
(f ---> g) ---> g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
g
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
f
Σ: Signature Γ: Theory a, b, c, d, e, f, g: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c wfd: well_formed d wfe: well_formed e wff: well_formed f wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
a and (b and (c and (d and e)))
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i pf: ML_proof_system Γ (A ---> B)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i pf: ML_proof_system Γ (A ---> B) HWF: well_formed (A ---> B)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i pf: ML_proof_system Γ (A ---> B) HWF: well_formed (A ---> B) wfA: well_formed A
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i pf: ML_proof_system Γ (A ---> B) HWF: well_formed (A ---> B) wfA: well_formed A wfB: well_formed B
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i H: Γ ⊢i A ---> B using i wfA: well_formed A wfB: well_formed B
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory C: Application_context A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ well_formed B
→ Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature Γ: Theory A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i A ---> B using i
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i
Σ: Signature Γ: Theory p: Pattern C: Application_context Prf: well_formed p A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i
Σ: Signature Γ: Theory A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i A ---> B using i
exact H.
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
well_formed A
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
well_formed B
Σ: Signature Γ: Theory C: Application_context p: Pattern Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
1-3: assumption.
Σ: Signature Γ: Theory p: Pattern C: Application_context Prf: well_formed p A, B: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B using i
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i
Σ: Signature Γ: Theory p: Pattern C: Application_context Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
Σ: Signature Γ: Theory p: Pattern C: Application_context Prf: well_formed p A, B: Pattern pi_generalized_evars: coEVarSet pi_substituted_svars: coSVarSet pi_uses_kt: bool pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false)
(ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) IHC: well_formed A
→ well_formed B
→ Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
→ Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt) WFA: well_formed A WFB: well_formed B H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
SVSubst := pi_substituted_svars,
KT := pi_uses_kt)
well_formed A
→ Γ ⊢i A using i → Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! ! A using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i TRANS:= syllogism_meta ?Goal0?Goal1?Goal2 EF PB: Γ ⊢i C.[□↦! A] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
apply TRANS.
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i
well_formed A
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦! A]
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A using i ANNA: Γ ⊢i ! A ---> ⊥ using i EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo H2: true = true H0: well_formed_positive A = true H1: well_formed_closed_ex_aux A 0 = true H4: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_generalized_evars i
Σ: Signature Γ: Theory A: Pattern C: Application_context i: ProofInfo H2: true = true H0: well_formed_positive A = true H1: well_formed_closed_ex_aux A 0 = true H4: well_formed_closed_mu_aux A 0 = true
well_formed A
→ Γ ⊢i A ---> ⊥ using i → Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i TRANS: Γ ⊢i C.[□↦A] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
exact TRANS.
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦A]
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo pile: ProofInfoLe
(ExGen := ∅, SVSubst := ∅, KT := false) i WFA: well_formed A H: Γ ⊢i A ---> ⊥ using i FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo H2: true = true H1: well_formed_positive A = true H3: well_formed_closed_ex_aux A 0 = true H0: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_generalized_evars i
Σ: Signature Γ: Theory C: Application_context A: Pattern i: ProofInfo H2: true = true H1: well_formed_positive A = true H3: well_formed_closed_ex_aux A 0 = true H0: well_formed_closed_mu_aux A 0 = true
Σ: Signature Γ: Theory AC: Application_context p, q: Pattern
well_formed p
→ well_formed q
→ Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p, q: Pattern
well_formed p
→ well_formed q
→ Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p, q: Pattern wfp: well_formed p wfq: well_formed q
Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q
Γ ⊢i p or q <---> p or q
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q
Γ ⊢i p or q <---> p or q
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q
Γ ⊢i p or q <---> p or q using BasicReasoning
apply pf_iff_equiv_refl; wf_auto2.
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)) *
(Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)))%type
Γ
⊢i AC.[□↦p or q] $ p0 <--->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 <--->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p] $ p0 or AC.[□↦q] $ p0 --->
AC.[□↦p or q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
try_solve_pile.
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i AC.[□↦p or q] $ p0 --->
(AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 --->
AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦q]
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using BasicReasoning
apply disj_right_intro; wf_auto2.
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)) *
(Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)))%type
Γ
⊢i p0 $ AC.[□↦p or q] <--->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] <--->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] --->
p0 $ AC.[□↦p or q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p or q])
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed ?B
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i p0 $ AC.[□↦p or q] ---> ?Busing i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i ?B ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p or q])
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ (AC.[□↦p] or AC.[□↦q]))
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i H: Γ
⊢i p0 $ AC.[□↦p or q] --->
p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) p': Pattern Heqp': p' = AC.[□↦p] IH1: Γ ⊢i AC.[□↦p or q] ---> p' or AC.[□↦q] using i IH2: Γ ⊢i p' or AC.[□↦q] ---> AC.[□↦p or q] using i H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or AC.[□↦q])
using i
Γ
⊢i p0 $ (p' or AC.[□↦q]) ---> p0 $ p' or p0 $ AC.[□↦q]
using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) p': Pattern Heqp': p' = AC.[□↦p] q': Pattern Heqq': q' = AC.[□↦q] IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using i IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using i H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using i
Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q' using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q p': Pattern Heqp': p' = AC.[□↦p] q': Pattern Heqq': q' = AC.[□↦q] H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q'
using BasicReasoning
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q p': Pattern Heqp': p' = AC.[□↦p] q': Pattern Heqq': q' = AC.[□↦q] H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p'
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q p': Pattern Heqp': p' = AC.[□↦p] q': Pattern Heqq': q' = AC.[□↦q] H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed q'
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q p': Pattern Heqp': p' = AC.[□↦p] q': Pattern Heqq': q' = AC.[□↦q] H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false) IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p0
all: subst; try_wfauto2.
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] --->
p0 $ AC.[□↦p or q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q i: ProofInfo Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p, q: Pattern wfp: well_formed p wfq: well_formed q IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (ex , ϕ)
→ well_formed ψ
→ Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
using BasicReasoning
Σ: Signature Γ: Theory ϕ, ψ: Pattern
well_formed (ex , ϕ)
→ well_formed ψ
→ Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
using BasicReasoning
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
using BasicReasoning
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
?pf BasicReasoning
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
well_formed (ex , ϕ)
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
well_formed ψ
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
well_formed (ex , ϕ)
exact wfϕ.
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
well_formed ψ
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
well_formed ψ
exact wfψ.}
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
(Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning
Σ: Signature Γ: Theory ϕ, ψ: Pattern wfϕ: well_formed (ex , ϕ) wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
(Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning
abstract(solve_pim_simple).}Defined.Tactic Notation"change""constraint""in"ident(H) :=
leti := fresh"i"in
remember_constraint as i;
eapply useGenericReasoning with (i := i) in H;
subst i;
[|(try_solve_pile)].
Σ: Signature Γ: Theory AC: Application_context p: Pattern x: evar
evar_is_fresh_in x AC.[□↦p]
→ well_formed (ex , p) = true
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p: Pattern x: evar
evar_is_fresh_in x AC.[□↦p]
→ well_formed (ex , p) = true
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p: Pattern x: evar Hx: evar_is_fresh_in x AC.[□↦p] Hwf: well_formed (ex , p) = true
Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p: Pattern x: evar Hx: evar_is_fresh_in x □.[□↦p] Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x}
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p] Hwf: well_formed (ex , p) = true IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅,
KT := false)
(* TODO automate this. The problem is that [well_formed_app] and others do not have [= true]; that is why [auto] does not work. But [auto] is not suitable for this anyway. A better way would be to create some `simpl_well_formed` tuple, that might use the type class mechanism for extension... *)
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (AC.[□↦p] $ p0) Hwf: well_formed (ex , p) = true IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅,
KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x}
well_formed
(exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature Γ: Theory AC: Application_context p0: Pattern Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (AC.[□↦p] $ p0) Hwf: well_formed (ex , p) = true IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅,
KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(AC.[□↦p^{evar:0↦x}] $ p0))
(* TODO automate this. The problem is that [well_formed_app] and others do not have [= true]; that is why [auto] does not work. But [auto] is not suitable for this anyway. A better way would be to create some `simpl_well_formed` tuple, that might use the type class mechanism for extension... *)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅,
KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x}
well_formed
(exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
⊢i AC.[□↦ex , p] <--->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅,
KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^[evar:0↦patt_free_evar x]] --->
exists_quantify x
AC.[□↦p^[evar:0↦patt_free_evar x]]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
exists_quantify x
AC.[□↦p]^[evar:0↦patt_free_evar x]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
(ex ,
AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
(ex ,
AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^{evar:0↦x} --->
(ex , AC.[□↦p]^{evar:0↦x}^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed_closed_ex_aux AC.[□↦p] 1
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature Γ: Theory p0: Pattern AC: Application_context Prf: well_formed p0 p: Pattern x: evar Hx: evar_is_fresh_in x (p0 $ AC.[□↦p]) Hwf: well_formed (ex , p) = true IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Hwfex: well_formed (ex , AC.[□↦p]) Hxfr1: evar_is_fresh_in x AC.[□↦p] Hxfrp: evar_is_fresh_in x p HxAC: x ∉ AC_free_evars AC Hwf': well_formed
(exists_quantify x AC.[□↦p^{evar:0↦x}]) Hwfeo: well_formed p^{evar:0↦x} Hwf'p0: well_formed
(exists_quantify x
(p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using BasicReasoning
apply Ex_quan; auto.}Defined.Add Search Blacklist"_elim".Add Search Blacklist"_graph_rect".Add Search Blacklist"_graph_mut".Add Search Blacklist"FunctionalElimination_".SectionFOL_helpers.Context {Σ : Signature}.(** NOTE: DO NOT REPLACE! The element variable in this function is needed to substitute in such pattern context, which contain arbitrary patterns, but the path to the element variable is concrete. For example, in `⌈ E ⌉ $ φ` the path to `E` does not contain any ∃-s, thus no new variables need to be generated for `mlRewrite`. *)Fixpointmaximal_exists_depth_to (depth : nat) (E : evar) (ψ : Pattern) : nat :=
match ψ with
| patt_bott => 0
| patt_sym _ => 0
| patt_bound_evar _ => 0
| patt_bound_svar _ => 0
| patt_free_svar _ => 0
| patt_free_evar E' =>
match (decide (E' = E)) with
| left _ => depth
| right _ => 0end
| patt_imp ψ₁ ψ₂
=> Nat.max
(maximal_exists_depth_to depth E ψ₁)
(maximal_exists_depth_to depth E ψ₂)
| patt_app ψ₁ ψ₂
=> Nat.max
(maximal_exists_depth_to depth E ψ₁)
(maximal_exists_depth_to depth E ψ₂)
| patt_exists ψ' => maximal_exists_depth_to (S depth) E ψ'
| patt_mu ψ' => maximal_exists_depth_to depth E ψ'
end.
Σ: Signature E: evar ψ: Pattern depth: nat
E ∉ free_evars ψ
→ maximal_exists_depth_to depth E ψ = 0
Σ: Signature E: evar ψ: Pattern depth: nat
E ∉ free_evars ψ
→ maximal_exists_depth_to depth E ψ = 0
maximal_exists_depth_to (S depth) E ψ =
S (maximal_exists_depth_to depth E ψ)
Σ: Signature ψ: Pattern
∀ (E : evar) (depth : nat),
E ∈ free_evars ψ
→ maximal_exists_depth_to (S depth) E ψ =
S (maximal_exists_depth_to depth E ψ)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]}
(if decide (x = E) then S depth else0) =
S (if decide (x = E) then depth else0)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]}
(if decide (x = E) then S depth else0) =
S (if decide (x = E) then depth else0)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} e: x = E H: decide (x = E) = left e
S depth = S depth
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} n: x ≠ E H: decide (x = E) = right n
0 = 1
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} n: x ≠ E H: decide (x = E) = right n
0 = 1
set_solver.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
reflexivity.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_exists_depth_to depth E ψ2 = 0 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_exists_depth_to depth E ψ2 = 0 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_exists_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_exists_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S (0 `max` maximal_exists_depth_to depth E ψ2)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
False
set_solver.}
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
reflexivity.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_exists_depth_to depth E ψ2 = 0 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_exists_depth_to depth E ψ2 = 0 n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_exists_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_exists_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S (0 `max` maximal_exists_depth_to depth E ψ2)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
(maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_exists_depth_to (S depth) E ψ1 =
S (maximal_exists_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
False
set_solver.}}Qed.
Σ: Signature φ: Pattern depth: nat x, e: evar
∀dbi : db_index,
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ
Σ: Signature φ: Pattern depth: nat x, e: evar
∀dbi : db_index,
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ
Σ: Signature φ: Pattern x, e: evar
∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
match compare_nat n HeNq with
| Nat_less _ _ _ => patt_bound_evar n
| Nat_equal _ _ _ => patt_free_evar e
| Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
end = 0
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to
(S depth) x φ^[evar:S HeNq↦
patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e e0: n = HeNq H0: compare_nat n HeNq = Nat_equal n HeNq e0
maximal_exists_depth_to depth x (patt_free_evar e) = 0
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to
(S depth) x φ^[evar:S HeNq↦
patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e e0: n = HeNq H0: compare_nat n HeNq = Nat_equal n HeNq e0
(if decide (e = x) then depth else0) = 0
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to
(S depth) x φ^[evar:S HeNq↦
patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e e0: n = HeNq H0: compare_nat n HeNq = Nat_equal n HeNq e0 e1: e = x H1: decide (e = x) = left e1
depth = 0
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e e0: n = HeNq H0: compare_nat n HeNq = Nat_equal n HeNq e0 n0: e ≠ x H1: decide (e = x) = right n0
0 = 0
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to
(S depth) x φ^[evar:S HeNq↦
patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature n: db_index x, e: evar depth: nat HeNq: db_index H: x ≠ e e0: n = HeNq H0: compare_nat n HeNq = Nat_equal n HeNq e0 n0: e ≠ x H1: decide (e = x) = right n0
0 = 0
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to
(S depth) x φ^[evar:S HeNq↦
patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ1, φ2: Pattern x, e: evar IHφ1: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ1^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ1 IHφ2: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ2^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ2 depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to (S depth) x
φ^[evar:S HeNq↦patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to (S depth) x
φ^[evar:S HeNq↦patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x
φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
Σ: Signature φ: Pattern x, e: evar IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ depth: nat HeNq: db_index H: x ≠ e
maximal_exists_depth_to depth x
φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_svar n
| Nat_equal _ _ _ => patt_free_svar X
| Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
end = 0
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_svar n
| Nat_equal _ _ _ => patt_free_svar X
| Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
end = 0
E ≠ x
→ maximal_mu_depth_to depth E ψ^{evar:n↦x} =
maximal_mu_depth_to depth E ψ
Σ: Signature depth: nat E: evar n: db_index x: evar ψ: Pattern Hne: E ≠ x
maximal_mu_depth_to depth E ψ^{evar:n↦x} =
maximal_mu_depth_to depth E ψ
Σ: Signature depth: nat E: evar n: db_index x: evar ψ: Pattern Hne: E ≠ x
maximal_mu_depth_to depth E
ψ^[evar:n↦patt_free_evar x] =
maximal_mu_depth_to depth E ψ
Σ: Signature E, x: evar ψ: Pattern Hne: E ≠ x
∀ (depth : nat) (n : db_index),
maximal_mu_depth_to depth E
ψ^[evar:n↦patt_free_evar x] =
maximal_mu_depth_to depth E ψ
Σ: Signature E, x: evar n: db_index Hne: E ≠ x depth: nat n': db_index
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_evar n
| Nat_equal _ _ _ => patt_free_evar x
| Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
end = 0
Σ: Signature E, x: evar n: db_index Hne: E ≠ x depth: nat n': db_index
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_evar n
| Nat_equal _ _ _ => patt_free_evar x
| Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
end = 0
Σ: Signature E, x: evar n: db_index Hne: E ≠ x depth: nat n': db_index e: n = n' H: compare_nat n n' = Nat_equal n n' e
(if decide (x = E) then depth else0) = 0
Σ: Signature E, x: evar n: db_index Hne: E ≠ x depth: nat n': db_index e: n = n' H: compare_nat n n' = Nat_equal n n' e e0: x = E H0: decide (x = E) = left e0
depth = 0
Σ: Signature E: evar Hne: E ≠ E depth: nat n': db_index H: compare_nat n' n' = Nat_equal n' n' erefl H0: decide (E = E) = left erefl
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_svar n
| Nat_equal _ _ _ => patt_free_svar X
| Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
end = 0
maximal_mu_depth_to depth E
match compare_nat n n' with
| Nat_less _ _ _ => patt_bound_svar n
| Nat_equal _ _ _ => patt_free_svar X
| Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
end = 0
case_match; simpl; tryreflexivity.}Qed.
Σ: Signature E: evar ψ: Pattern depth: nat
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
Σ: Signature E: evar ψ: Pattern depth: nat
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
maximal_mu_depth_to (S depth) E ψ =
S (maximal_mu_depth_to depth E ψ)
Σ: Signature ψ: Pattern
∀ (E : evar) (depth : nat),
E ∈ free_evars ψ
→ maximal_mu_depth_to (S depth) E ψ =
S (maximal_mu_depth_to depth E ψ)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]}
(if decide (x = E) then S depth else0) =
S (if decide (x = E) then depth else0)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]}
(if decide (x = E) then S depth else0) =
S (if decide (x = E) then depth else0)
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} e: x = E H: decide (x = E) = left e
S depth = S depth
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} n: x ≠ E H: decide (x = E) = right n
0 = 1
Σ: Signature x, E: evar depth: nat Hin: E ∈ {[x]} n: x ≠ E H: decide (x = E) = right n
0 = 1
set_solver.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
reflexivity.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_mu_depth_to depth E ψ2 = 0 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_mu_depth_to depth E ψ2 = 0 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_mu_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_mu_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S (0 `max` maximal_mu_depth_to depth E ψ2)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
False
set_solver.}
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 e0: E ∈ free_evars ψ2
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
reflexivity.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: E ∉ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_mu_depth_to depth E ψ2 = 0 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 e: E ∈ free_evars ψ1 n: maximal_mu_depth_to depth E ψ2 = 0 n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_mu_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: maximal_mu_depth_to depth E ψ1 = 0 e: E ∈ free_evars ψ2 n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S (0 `max` maximal_mu_depth_to depth E ψ2)
lia.
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
(maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2)
Σ: Signature ψ1, ψ2: Pattern IHψ1: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ1
→ maximal_mu_depth_to (S depth) E ψ1 =
S (maximal_mu_depth_to depth E ψ1) IHψ2: ∀ (E : evar) (depth : nat),
E ∈ free_evars ψ2
→ maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ2) E: evar depth: nat Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2 n: E ∉ free_evars ψ1 n0: E ∉ free_evars ψ2
apply IHn1.}}Qed.(** Note: we cannot reuse NoDup, until the proof system is formalised as `... -> Set`. *)Fixpointno_dups {A : Set} {eqdec : EqDecision A} (l : list A) :=
match l with
| [] => True
| x::xs => x ∉ xs /\ no_dups xs
end.Classfresh_evars (l : list evar) (s : EVarSet) :=
{
evar_duplicates : no_dups l;
all_evars_fresh : forallx, x ∈ l -> x ∉ s;
}.
Σ: Signature el: list evar s, s': EVarSet
fresh_evars el s → s' ⊆ s → fresh_evars el s'
Σ: Signature el: list evar s, s': EVarSet
fresh_evars el s → s' ⊆ s → fresh_evars el s'
Σ: Signature el: list evar s, s': EVarSet H: fresh_evars el s H0: s' ⊆ s
fresh_evars el s'
Σ: Signature el: list evar s, s': EVarSet evar_duplicates0: no_dups el all_evars_fresh0: ∀x : evar, x ∈ el → x ∉ s H0: s' ⊆ s
no_dups el
Σ: Signature el: list evar s, s': EVarSet evar_duplicates0: no_dups el all_evars_fresh0: ∀x : evar, x ∈ el → x ∉ s H0: s' ⊆ s
∀x : evar, x ∈ el → x ∉ s'
Σ: Signature el: list evar s, s': EVarSet evar_duplicates0: no_dups el all_evars_fresh0: ∀x : evar, x ∈ el → x ∉ s H0: s' ⊆ s
∀x : evar, x ∈ el → x ∉ s'
Σ: Signature el: list evar s, s': EVarSet evar_duplicates0: no_dups el all_evars_fresh0: ∀x : evar, x ∈ el → x ∉ s H0: s' ⊆ s x: evar H: x ∈ el
x ∉ s'
set_solver.Qed.
Σ: Signature x: evar el: list evar s: EVarSet
fresh_evars (x :: el) s → fresh_evars el s
Σ: Signature x: evar el: list evar s: EVarSet
fresh_evars (x :: el) s → fresh_evars el s
Σ: Signature x: evar el: list evar s: EVarSet H: fresh_evars (x :: el) s
fresh_evars el s
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s
no_dups el
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀x : evar, x ∈ el → x ∉ s
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: (x ∉ el) ∧ no_dups el all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s
no_dups el
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀x : evar, x ∈ el → x ∉ s
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀x : evar, x ∈ el → x ∉ s
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s x0: evar H: x0 ∈ el
x0 ∉ s
Σ: Signature x: evar el: list evar s: EVarSet evar_duplicates0: no_dups (x :: el) all_evars_fresh0: ∀x0 : evar, x0 ∈ x :: el → x0 ∉ s x0: evar H: x0 ∈ el
x0 ∈ x :: el
nowconstructor2.Qed.Classfresh_svars (l : list svar) (s : SVarSet) :=
{
svar_duplicates : no_dups l;
all_svars_fresh : forallX, X ∈ l -> X ∉ s;
}.
Σ: Signature sl: list svar s, s': SVarSet
fresh_svars sl s → s' ⊆ s → fresh_svars sl s'
Σ: Signature sl: list svar s, s': SVarSet
fresh_svars sl s → s' ⊆ s → fresh_svars sl s'
Σ: Signature sl: list svar s, s': SVarSet H: fresh_svars sl s H0: s' ⊆ s
fresh_svars sl s'
Σ: Signature sl: list svar s, s': SVarSet svar_duplicates0: no_dups sl all_svars_fresh0: ∀X : svar, X ∈ sl → X ∉ s H0: s' ⊆ s
no_dups sl
Σ: Signature sl: list svar s, s': SVarSet svar_duplicates0: no_dups sl all_svars_fresh0: ∀X : svar, X ∈ sl → X ∉ s H0: s' ⊆ s
∀X : svar, X ∈ sl → X ∉ s'
Σ: Signature sl: list svar s, s': SVarSet svar_duplicates0: no_dups sl all_svars_fresh0: ∀X : svar, X ∈ sl → X ∉ s H0: s' ⊆ s
∀X : svar, X ∈ sl → X ∉ s'
Σ: Signature sl: list svar s, s': SVarSet svar_duplicates0: no_dups sl all_svars_fresh0: ∀X : svar, X ∈ sl → X ∉ s H0: s' ⊆ s X: svar H: X ∈ sl
X ∉ s'
set_solver.Qed.
Σ: Signature X: evar sl: list evar s: EVarSet
fresh_evars (X :: sl) s → fresh_evars sl s
Σ: Signature X: evar sl: list evar s: EVarSet
fresh_evars (X :: sl) s → fresh_evars sl s
Σ: Signature X: evar sl: list evar s: EVarSet H: fresh_evars (X :: sl) s
fresh_evars sl s
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s
no_dups sl
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s
∀x : evar, x ∈ sl → x ∉ s
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: (X ∉ sl) ∧ no_dups sl all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s
no_dups sl
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s
∀x : evar, x ∈ sl → x ∉ s
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s
∀x : evar, x ∈ sl → x ∉ s
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s x: evar H: x ∈ sl
x ∉ s
Σ: Signature X: evar sl: list evar s: EVarSet evar_duplicates0: no_dups (X :: sl) all_evars_fresh0: ∀x : evar, x ∈ X :: sl → x ∉ s x: evar H: x ∈ sl
x ∈ X :: sl
nowconstructor2.Qed.
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
(* TODO: remove the well-formedness constraints on this lemma*)
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars ψ^[[evar:E↦p]]
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0↦?x} --->
(ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0↦?x} --->
(ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature Γ: Theory E: evar ψ: Pattern x: evar p, q: Pattern gpi: ProofInfo kt: bool evs: coEVarSet svs: coSVarSet HxneqE: x ≠ E wfψ: well_formed (ex , ψ) wfp: well_formed p wfq: well_formed q Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q Heqx2: x ∈ evs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs, KT := kt) gpi IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
ψ^[[evar:E↦q]]^{evar:0↦x} using gpi IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature Γ: Theory ψ1, ψ2, p, q: Pattern E: evar i: ProofInfo wfψ1: well_formed ψ1 wfψ2: well_formed ψ2 wfp: well_formed p wfq: well_formed q pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i Hwf1: well_formed ψ1^[[evar:E↦p]] = true HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
wfψ1 Hwf2: well_formed ψ1^[[evar:E↦q]] = true HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
wfψ1 Hwf3: well_formed ψ2^[[evar:E↦p]] = true HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
wfψ2 Hwf4: well_formed ψ2^[[evar:E↦q]] = true HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
abstract (wf_auto2).}Defined.
Σ: Signature φ: Pattern x, y: evar
x ∉ free_evars φ
→ count_evar_occurrences x
φ^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ
Σ: Signature φ: Pattern x, y: evar
x ∉ free_evars φ
→ count_evar_occurrences x
φ^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ
Σ: Signature x0, x, y: evar H: x ∉ {[x0]}
count_evar_occurrences x
(if decide (y = x0)
then patt_free_evar x
else patt_free_evar x0) =
(if decide (x0 = y) then1else0)
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature x0, x, y: evar H: x ∉ {[x0]}
count_evar_occurrences x
(if decide (y = x0)
then patt_free_evar x
else patt_free_evar x0) =
(if decide (x0 = y) then1else0)
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
all: set_solver.
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature φ1, φ2: Pattern x, y: evar IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
φ1^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ2 H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
all: set_solver.Qed.Definitionmu_in_evar_pathEψsdepth := negb (Nat.eqb 0 (maximal_mu_depth_to sdepth E ψ)).
Σ: Signature sz: nat Γ: Theory p, q: Pattern evs: coEVarSet svs: coSVarSet wfp: well_formed p wfq: well_formed q E: evar ψ: Pattern edepth, sdepth: nat Hsz: size' ψ ≤ sz wfψ: well_formed ψ gpi: ProofInfo el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi pf: Γ ⊢i p <---> q using gpi
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern evs: coEVarSet svs: coSVarSet wfp: well_formed p wfq: well_formed q E: evar ψ: Pattern edepth, sdepth: nat Hsz: size' ψ ≤ sz wfψ: well_formed ψ gpi: ProofInfo el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs pile: ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi pf: Γ ⊢i p <---> q using gpi
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
(* TODO: if there were a size function for coEVarSet/coSVarSet, then Hel3/Hsl3 would be not necessary *)
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar
∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ ∪ free_svars p
∪ free_svars q)
→ length sl
≥ maximal_mu_depth_to sdepth E
ψ
→ (∀X : svar,
X ∈ sl → X ∈ svs)
→ Γ
⊢i ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi
Σ: Signature Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ 0 evs: coEVarSet svs: coSVarSet gpi: ProofInfo pile: ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→
length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]] using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo pile: ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo pile: ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth) gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ <---> ψ using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
ProofInfoLe BasicReasoning gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
well_formed ψ
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
well_formed ψ
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEnotinψ: E ∉ free_evars ψ
well_formed ψ
abstract (wf_auto2).}
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ: Pattern wfψ: well_formed ψ Hsz: size' ψ ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars ψ ∪ free_evars p ∪ free_evars q
∪ {[E]}) Hel2: length el ≥ maximal_exists_depth_to edepth E ψ Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars ψ ∪ free_svars p ∪ free_svars q) Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat x: evar wfψ: well_formed (patt_free_evar x) Hsz: 1 ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (patt_free_evar x) ∪ free_evars p
∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E
(patt_free_evar x) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (patt_free_evar x) ∪ free_svars p
∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
(patt_free_evar x) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (patt_free_evar x)
Γ
⊢i (if decide (E = x) then p else patt_free_evar x) <--->
(if decide (E = x) then q else patt_free_evar x)
using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat x: svar wfψ: well_formed (patt_free_svar x) Hsz: 1 ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (patt_free_svar x) ∪ free_evars p
∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E
(patt_free_svar x) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (patt_free_svar x) ∪ free_svars p
∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
(patt_free_svar x) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat n: db_index wfψ: well_formed (patt_bound_evar n) Hsz: 1 ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (patt_bound_evar n)
∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E
(patt_bound_evar n) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (patt_bound_evar n)
∪ free_svars p ∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
(patt_bound_evar n) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat n: db_index wfψ: well_formed (patt_bound_svar n) Hsz: 1 ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (patt_bound_svar n)
∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E
(patt_bound_svar n) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (patt_bound_svar n)
∪ free_svars p ∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
(patt_bound_svar n) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat sigma: symbols wfψ: well_formed (patt_sym sigma) Hsz: 1 ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (patt_sym sigma) ∪ free_evars p
∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E
(patt_sym sigma) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (patt_sym sigma) ∪ free_svars p
∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature sz: nat Γ: Theory p, q: Pattern wfp: well_formed p wfq: well_formed q E: evar IHsz: ∀ (edepthsdepth : nat) (ψ : Pattern),
well_formed ψ
→ size' ψ ≤ sz
→ ∀ (evs : coEVarSet)
(svs : coSVarSet)
(gpi : ProofInfo),
ProofInfoLe
(ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth)
gpi
→ Γ ⊢i p <---> q using gpi
→ ∀el : list evar,
fresh_evars el
(free_evars ψ ∪ free_evars p
∪ free_evars q ∪ {[E]})
→ length el
≥ maximal_exists_depth_to
edepth E ψ
→ (∀x : evar, x ∈ el → x ∈ evs)
→ ∀sl : list svar,
fresh_svars sl
(free_svars ψ
∪
free_svars p
∪
free_svars q)
→ length sl
≥
maximal_mu_depth_to
sdepth E ψ
→
(∀X : svar,
X ∈ sl → X ∈ svs)
→
Γ
⊢i
ψ^[[evar:E↦p]] <--->
ψ^[[evar:E↦q]]
using gpi edepth, sdepth: nat ψ1, ψ2: Pattern wfψ: well_formed (ψ1 $ ψ2) Hsz: S (size' ψ1 + size' ψ2) ≤ S sz evs: coEVarSet svs: coSVarSet gpi: ProofInfo i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo pile: ProofInfoLe i' gpi pf: Γ ⊢i p <---> q using gpi el: list evar Hel1: fresh_evars el
(free_evars (ψ1 $ ψ2) ∪ free_evars p
∪ free_evars q ∪ {[E]}) Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2) Hel3: ∀x : evar, x ∈ el → x ∈ evs sl: list svar Hsl1: fresh_svars sl
(free_svars (ψ1 $ ψ2) ∪ free_svars p
∪ free_svars q) Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2) Hsl3: ∀X : svar, X ∈ sl → X ∈ svs HEinψ: E ∈ free_evars (ψ1 $ ψ2)
maximal_exists_depth_to edepth x ψ =
maximal_exists_depth_to edepth x ψ
reflexivity.
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l)
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: x ∉ free_evars_of_list l
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: maximal_exists_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x ψ =
maximal_exists_depth_to edepth x ψ
maximal_mu_depth_to edepth x ψ =
maximal_mu_depth_to edepth x ψ
reflexivity.
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l)
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: x ∉ free_evars_of_list l
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
Σ: Signature a: Pattern l: list Pattern ψ: Pattern x: evar edepth: nat IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ Hin: x ∉ free_evars_of_list (a :: l) Ha: x ∉ free_evars a HIND: maximal_mu_depth_to edepth x
(foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x ψ =
maximal_mu_depth_to edepth x ψ
rewrite maximal_mu_depth_to_0; auto.Qed.(* NOTE: This version of the iterated congruence lemma is proved by induction. There is a way, to prove this lemma without induction (see `TEST_proofmode_proof_size.v`), but the generated proof term becomes much more larger (2-3 times larger than the induction-based). This is because the proof of the congruence lemma is more complex for bigger contexts. *)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi
wf l
→ Γ ⊢i p <---> q using gpi
→ Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi
wf l
→ Γ ⊢i p <---> q using gpi
→ Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfl: wf l Himp: Γ ⊢i p <---> q using gpi
Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfl: wf [] Himp: Γ ⊢i p <---> q using gpi
Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfl: wf (a :: l) Himp: Γ ⊢i p <---> q using gpi IHl: wf l
→ Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
(a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfl: wf [] Himp: Γ ⊢i p <---> q using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) <--->
(a ---> foldr patt_imp (C [q]) l)
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
((a ---> foldr patt_imp (C [p]) l) --->
a ---> foldr patt_imp (C [q]) l)
and ((a ---> foldr patt_imp (C [q]) l) --->
a ---> foldr patt_imp (C [p]) l)
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) --->
a ---> foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [q]) l) --->
a ---> foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) --->
a ---> foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
--------------------------------------
a ---> foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
well_formed (foldr patt_imp (C [p]) l)
wf_auto2.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
a
using gpi
mlExactn 1.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
mlExactn 2.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [q]) l) --->
a ---> foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
--------------------------------------
a ---> foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q])
well_formed (foldr patt_imp (C [q]) l)
wf_auto2.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
a
using gpi
mlExactn 1.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
foldr patt_imp (C [p]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
foldr patt_imp (C [p]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx a: Pattern l: list Pattern wfp: well_formed p wfq: well_formed q wfC: PC_wf C gpi: ProofInfo pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi wfa: well_formed a = true wfl: foldr andb true (map well_formed l) = true Himp: Γ ⊢i p <---> q using gpi IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
foldr patt_imp (C [p]) l using gpi wfal: wf (a :: l) Hwf1: well_formed
(foldr patt_imp (C [p]) l <--->
foldr patt_imp (C [q]) l) Hwf2: well_formed (p <---> q) H: well_formed (C [p]) H0: well_formed (C [q]) Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
mlExactn 2.Defined.
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo
Γ ⊢i p <---> q using i → well_formed p
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo
Γ ⊢i p <---> q using i → well_formed p
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i
well_formed p
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i H': ML_proof_system Γ (p <---> q)
well_formed p
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i H': well_formed (p <---> q)
well_formed p
wf_auto2.Qed.
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo
Γ ⊢i p <---> q using i → well_formed q
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo
Γ ⊢i p <---> q using i → well_formed q
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i
well_formed q
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i H': ML_proof_system Γ (p <---> q)
well_formed q
Σ: Signature Γ: Theory p, q: Pattern i: ProofInfo H: Γ ⊢i p <---> q using i H': well_formed (p <---> q)
well_formed q
wf_auto2.Qed.
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C pf: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi
→ ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪ free_evars q
∪ {[pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C) (pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p ∪ free_svars q)
(maximal_mu_depth_to 0 (pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
gpi
→ Γ Ⱶ
l--------------------------------------
C [p]
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C pf: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi
→ ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪ free_evars q
∪ {[pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C) (pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p ∪ free_svars q)
(maximal_mu_depth_to 0 (pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
gpi
→ Γ Ⱶ
l--------------------------------------
C [p]
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C Hpiffq: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi
→ ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪ free_evars q
∪ {[pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C) (pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p ∪ free_svars q)
(maximal_mu_depth_to 0 (pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
gpi
→ Γ Ⱶ
l--------------------------------------
C [p]
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C Hpiffq: Γ ⊢i p <---> q using gpi H: Γ Ⱶ
l--------------------------------------
C [q]
using gpi
pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi
Γ Ⱶ
l--------------------------------------
C [p]
using gpi
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C Hpiffq: Γ ⊢i p <---> q using gpi H: well_formed
(mlConclusion
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
))
→ wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
)))
→ mlTheory
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
)
⊢i foldr patt_imp
(mlConclusion
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
))
(patterns_of
(mlHypotheses
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
)))
using mlInfo
(Γ Ⱶ
l--------------------------------------
C [q]
using gpi
) pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi
well_formed
(mlConclusion
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
))
→ wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
)))
→ mlTheory
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
)
⊢i foldr patt_imp
(mlConclusion
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
))
(patterns_of
(mlHypotheses
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
)))
using mlInfo
(Γ Ⱶ
l--------------------------------------
C [p]
using gpi
)
Σ: Signature Γ: Theory p, q: Pattern C: PatternCtx l: hypotheses gpi: ProofInfo wfC: PC_wf C Hpiffq: Γ ⊢i p <---> q using gpi H: well_formed (C [q])
→ wf (patterns_of l)
→ Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi pile: ProofInfoLe
(ExGen := list_to_set
(evar_fresh_seq
(free_evars (pcPattern C)
∪ free_evars p ∪
free_evars q ∪ {[
pcEvar C]})
(maximal_exists_depth_to 0
(pcEvar C)
(pcPattern C))),
SVSubst := list_to_set
(svar_fresh_seq
(free_svars (pcPattern C)
∪ free_svars p
∪ free_svars q)
(maximal_mu_depth_to 0
(pcEvar C)
(pcPattern C))),
KT := mu_in_evar_path
(pcEvar C) (pcPattern C) 0) gpi
well_formed a
→ well_formed a'
→ well_formed b
→ Γ ⊢ a <---> a'
→ Γ
⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
using AnyReasoning
Σ: Signature Γ: Theory a, a', b: Pattern x: evar
well_formed a
→ well_formed a'
→ well_formed b
→ Γ ⊢ a <---> a'
→ Γ
⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
using AnyReasoning
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
using AnyReasoning
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
well_formed
((a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x))
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
(a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
well_formed
((a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x))
abstract(wf_auto2).
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
(a $ a $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
(a $ a' $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
(a $ a' $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a ---> patt_free_evar x)
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a' $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a ---> patt_free_evar x)
using AnyReasoning
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a' $ b $ a ---> patt_free_evar x) <--->
(a $ a' $ b $ a ---> patt_free_evar x)
using BasicReasoning
Σ: Signature Γ: Theory a, a', b: Pattern x: evar wfa: well_formed a wfa': well_formed a' wfb: well_formed b Hiff: Γ ⊢ a <---> a'
well_formed (a $ a' $ b $ a ---> patt_free_evar x)
abstract(wf_auto2).Defined.(* TODO: de-duplicate the code *)#[local]
LtacconvertToNNF_rewrite_pat Ctx p i :=
lazymatch p with
| (! ! ?x) =>
letH' := fresh"H"inpose proof (@not_not_eq _ Ctx x ltac:(wf_auto2)) as H';
apply (@useBasicReasoning _ _ _ i) in H';
repeat (mlRewrite H' at1);
tryclear H';
convertToNNF_rewrite_pat Ctx x i
| patt_not (patt_and ?x?y) =>
letH' := fresh"H"inpose proof (@deMorgan_nand _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
apply (@useBasicReasoning _ _ _ i) in H';
repeat (mlRewrite H' at1);
tryclear H';
convertToNNF_rewrite_pat Ctx (!x or !y) i
| patt_not (patt_or ?x?y) =>
letH' := fresh"H"inpose proof (@deMorgan_nor _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
apply (@useBasicReasoning _ _ _ i) in H';
repeat (mlRewrite H' at1);
tryclear H';
convertToNNF_rewrite_pat Ctx (!x and !y) i
| patt_not (?x ---> ?y) =>
letH' := fresh"H"inpose proof (@nimpl_eq_and _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
apply (@useBasicReasoning _ _ _ i) in H';
repeat (mlRewrite H' at1);
tryclear H';
convertToNNF_rewrite_pat Ctx (x and !y) i
| (?x ---> ?y) =>
letH' := fresh"H"inpose proof (@impl_eq_or _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
apply (@useBasicReasoning _ _ _ i) in H';
repeat (mlRewrite H' at1);
tryclear H';
convertToNNF_rewrite_pat Ctx (!x or y) i
| patt_and ?x?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i
| patt_or ?x?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i
| _ => idtacend.#[local]
LtactoNNF :=
repeat mlRevertLast;
match goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm?Ctx?ll?g?i) ]
=>
mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@not_not_elim Sgm Ctx g ltac:(wf_auto2)));
convertToNNF_rewrite_pat Ctx (!g) i
end.
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ
⊢i b and (a or b) and ! b and (a or a) and a --->
⊥ using BasicReasoning
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ
⊢i b and (a or b) and ! b and (a or a) and a --->
⊥ using BasicReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed
(b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed
(b and (a or b) and ! b and (a or a) and a ---> ⊥)
wf_auto2.
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
! (b and (a or b) and ! b and (a or a) and a and ! ⊥)
using BasicReasoning
Abort.#[local]
LtacrfindContradictionTo a ll k :=
match ll with
| ((mkNH _ ?name (! a)) :: ?m) =>
mlApply name; mlExactn k
| ((mkNH _ _ _) :: ?m) =>
rfindContradictionTo a m k
| _ => failend.#[local]
LtacfindContradiction l k:=
match l with
| ((mkNH _ _ ?a) :: ?m) =>
match goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm?Ctx?ll?g?i) ]
=>
try rfindContradictionTo a ll k;
letkk := evalcomputein ( k + 1 ) in
(findContradiction m kk)
end
| _ => failend.#[local]
LtacfindContradiction_start :=
match goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm?Ctx?l?g?i) ]
=>
match goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm?Ctx?l?g?i) ]
=>
findContradiction l 0endend.#[local]
LtacbreakHyps l :=
match l with
| ((mkNH _ ?name (?xand?y)) :: ?m) =>
mlDestructAnd name
| ((mkNH _ ?name (?x or ?y)) :: ?m) =>
mlDestructOr name
| ((mkNH _ ?name?x) :: ?m) =>
breakHyps m
end.#[local]
LtacmlTautoBreak := repeatmatch goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm?Ctx?l?g?i) ]
=>
lazymatch g with
| (⊥) =>
breakHyps l
| _ => mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@bot_elim _ _ g _))
endend.Ltactry_solve_pile2 fallthrough :=
lazymatch goal with
| [ |- ProofInfoLe _ _] => tryapply pile_refl; try_solve_pile; fallthrough
| _ => idtacend.#[global]
LtacmlTauto :=
_ensureProofMode;
unshelve(
try (
toNNF; (try_solve_pile2 shelve);
repeat mlIntro;
mlTautoBreak;
findContradiction_start
)
)
.
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ
⊢i b and (a or b) and ! b and (a or a) and a --->
⊥ using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ
⊢i b and (a or b) and ! b and (a or a) and a --->
⊥ using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥
using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed
(b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed
(b and (a or b) and ! b and (a or a) and a ---> ⊥)
wf_auto2.
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
(* TODO: fail loudly if there is something else than AnyReasoning *)mlTauto.Defined.
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed (a ---> ! a ---> b)
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
a ---> ! a ---> b
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed (a ---> ! a ---> b)
wf_auto2.
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
a ---> ! a ---> b
mlTauto.Defined.
Σ: Signature Γ: Theory a, b, c: Pattern
well_formed a
→ well_formed b
→ well_formed c
→ Γ
⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
using AnyReasoning
Σ: Signature Γ: Theory a, b, c: Pattern
well_formed a
→ well_formed b
→ well_formed c
→ Γ
⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
using AnyReasoning
Σ: Signature Γ: Theory a, b, c: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c
Γ ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
using AnyReasoning
Σ: Signature Γ: Theory a, b, c: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c
well_formed
((a ---> b) ---> (b ---> c) ---> a or b ---> c)
Σ: Signature Γ: Theory a, b, c: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c
Γ Ⱶ
(a ---> b) ---> (b ---> c) ---> a or b ---> c
Σ: Signature Γ: Theory a, b, c: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c
well_formed
((a ---> b) ---> (b ---> c) ---> a or b ---> c)
wf_auto2.
Σ: Signature Γ: Theory a, b, c: Pattern wfa: well_formed a wfb: well_formed b wfc: well_formed c
Γ Ⱶ
(a ---> b) ---> (b ---> c) ---> a or b ---> c
mlTauto. (* Slow *)Defined.
Σ: Signature Γ: Theory a: Pattern
well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature Γ: Theory a: Pattern
well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
well_formed (! (a and ! a))
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ Ⱶ
! (a and ! a)
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
well_formed (! (a and ! a))
wf_auto2.
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ Ⱶ
! (a and ! a)
mlTauto.Defined.
Σ: Signature Γ: Theory a: Pattern
well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature Γ: Theory a: Pattern
well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
well_formed (! ! a ---> a)
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ Ⱶ
! ! a ---> a
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
well_formed (! ! a ---> a)
wf_auto2.
Σ: Signature Γ: Theory a: Pattern wfa: well_formed a
Γ Ⱶ
! ! a ---> a
mlTauto.Defined.
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern
well_formed a
→ well_formed b
→ Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed (((a ---> b) ---> a) ---> a)
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
Γ Ⱶ
((a ---> b) ---> a) ---> a
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b
well_formed (((a ---> b) ---> a) ---> a)
wf_auto2.
Σ: Signature Γ: Theory a, b: Pattern wfa: well_formed a wfb: well_formed b